Intermediately Executed Code is the Key to Find Refactorings that Improve Temporal Data Locality

C

Improvisation as a creative dialogue

Our paper will describe the creative process of Zaum: Beyond Mind an interactive sound theater performance, and examine the role of improvisation in shaping the piece. Zaum is a modular performance for voice, bandoneon, piano and electronics- integrating both live interactive elements and fixed sounds – with lighting, and video projection. While the creative process included traditional modes of composition, a significant aspect in melding the contribution of two composers - each with a different approach to composition - shares important attributes with improvisation. It is to do with creative listening, adjusting our individual contribution in response to changing contexts, and developing a shared sense of musical pacing and narrative. Improvisation also played a significant role in developing the technological, interactive elements of the piece with a co-evolution of the programming and the performance over a lengthy process of exploration and adjustments. This process, therefore, entails multiple dialogues, musical as well as verbal, between us as a duo and between us and our instruments. On the way we discovered that analytical reflection, despite its connotations of cerebral processes popularly portrayed as in opposition to the spontaneity required in improvisation, played a crucial role in the shaping of the piece

Performance visualization using XML representations

The intermediate representation (IR) forms the information exchanged among different passes of program compilation. The intermediate format proposed for extensibility and persistence is written in XML. In this way, the program transformations that were internal to the compiler become visible. The hierarchical structure of XML makes a natural representation for the abstract syntax tree (AST). A compiler can parse the program source into an IR, then output it as an XML document. Separated by orthogonal namespaces, other IRs are also presented in the same XML document, gathering program information such as dependence vectors, transforming matrices, iteration spaces dependence graphs and cache reuse distances. This XML document can be exchanged between the compiler and program visualizers for parallelism and locality

Path-based reuse distance analysis

Profiling can effectively analyze program behavior and provide critical information for feedback-directed or dynamic optimizations. Based on memory profiling, reuse distance analysis has shown much promise in predicting data locality for a program using inputs other than the profiled ones. Both wholeprogram and instruction-based locality can be accurately predicted by reuse distance analysis. Reuse distance analysis abstracts a cluster of memory references for a particular instruction having similar reuse distance values into a locality pattern. Prior work has shown that a significant number of memory instructions have multiple locality patterns, a property not desirable for many instruction-based memory optimizations. This paper investigates the relationship between locality patterns and execution paths by analyzing reuse distance distribution along each dynamic path to an instruction. Here a path is defined as the program execution trace from the previous access of a memory location to the current access. By differentiating locality patterns with the context of execution paths, the proposed analysis can expose optimization opportunities tailored only to a specific subset of paths leading to an instruction. In this paper, we present an effective method for path-based reuse distance profiling and analysis. We have observed that a significant percentage of the multiple locality patterns for an instruction can be uniquely related to a particular execution path in the program. In addition, we have also investigated the influence of inputs on reuse distance distribution for each path/instruction pair. The experimental results show that the path-based reuse distance is highly predictable, as a function of the data size, for a set of SPEC CPU2000 programs